home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_guile.idb / usr / freeware / include / libguile / __scm.h.z / __scm.h
Encoding:
C/C++ Source or Header  |  1999-04-16  |  12.2 KB  |  500 lines
  1. /* classes: h_files */
  2.  
  3. #ifndef __SCMH
  4. #define __SCMH
  5. /*    Copyright (C) 1995, 1996, 1998 Free Software Foundation, Inc.
  6.  * 
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2, or (at your option)
  10.  * any later version.
  11.  * 
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  * 
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this software; see the file COPYING.  If not, write to
  19.  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20.  * Boston, MA 02111-1307 USA
  21.  *
  22.  * As a special exception, the Free Software Foundation gives permission
  23.  * for additional uses of the text contained in its release of GUILE.
  24.  *
  25.  * The exception is that, if you link the GUILE library with other files
  26.  * to produce an executable, this does not by itself cause the
  27.  * resulting executable to be covered by the GNU General Public License.
  28.  * Your use of that executable is in no way restricted on account of
  29.  * linking the GUILE library code into it.
  30.  *
  31.  * This exception does not however invalidate any other reasons why
  32.  * the executable file might be covered by the GNU General Public License.
  33.  *
  34.  * This exception applies only to the code released by the
  35.  * Free Software Foundation under the name GUILE.  If you copy
  36.  * code from other Free Software Foundation releases into a copy of
  37.  * GUILE, as the General Public License permits, the exception does
  38.  * not apply to the code that you add in this way.  To avoid misleading
  39.  * anyone as to the status of such modified files, you must delete
  40.  * this exception notice from them.
  41.  *
  42.  * If you write modifications of your own for GUILE, it is your choice
  43.  * whether to permit this exception to apply to your modifications.
  44.  * If you do not wish that, delete this exception notice.  */
  45.  
  46. /* {Supported Options}
  47.  *
  48.  * These may be defined or undefined.
  49.  */
  50.  
  51. /* If the compile FLAG `SCM_CAUTIOUS' is #defined then the number of
  52.  * arguments is always checked for application of closures.  If the
  53.  * compile FLAG `SCM_RECKLESS' is #defined then they are not checked.
  54.  * Otherwise, number of argument checks for closures are made only when
  55.  * the function position (whose value is the closure) of a combination is
  56.  * not an ILOC or GLOC.  When the function position of a combination is a
  57.  * symbol it will be checked only the first time it is evaluated because
  58.  * it will then be replaced with an ILOC or GLOC.
  59.  */
  60. #undef SCM_RECKLESS
  61. #define SCM_CAUTIOUS
  62.  
  63. /* After looking up a local for the first time, rewrite the
  64.  * code graph, caching its position.
  65.  */
  66. #define MEMOIZE_LOCALS
  67.  
  68. /* All the number support there is.
  69.  */
  70. #define SCM_FLOATS
  71. #define BIGNUMS
  72.  
  73. /* GC should relinquish empty cons-pair arenas. 
  74.  */
  75. #define GC_FREE_SEGMENTS
  76.  
  77. /* Provide a scheme-accessible count-down timer that
  78.  * generates a pseudo-interrupt.
  79.  */
  80. #define TICKS
  81.  
  82.  
  83. /* Use engineering notation when converting numbers strings?
  84.  */
  85. #undef ENGNOT
  86.  
  87. /* Include support for uniform arrays?
  88.  *
  89.  * Possibly some of the initialization code depends on this
  90.  * being defined, but that is a bug and should be fixed.
  91.  */
  92. #define ARRAYS
  93.  
  94. #undef SCM_CAREFUL_INTS
  95.  
  96. /* {Unsupported Options}
  97.  *
  98.  * These must be defined as given here.
  99.  */
  100.  
  101.  
  102. #define CCLO
  103.  
  104. /* Guile Scheme supports the #f/() distinction; Guile Lisp won't.  We
  105.    have horrible plans for their unification.  */
  106. #undef SICP
  107.  
  108.  
  109.  
  110. /* Random options (not yet supported or in final form). */
  111.  
  112. #define STACK_CHECKING
  113. #undef NO_CEVAL_STACK_CHECKING
  114. #undef LONGLONGS
  115.  
  116. /* Some auto-generated .h files contain unused prototypes
  117.  * that need these typedefs.
  118.  */
  119. typedef long long_long;
  120. typedef unsigned long ulong_long;
  121.  
  122.  
  123.  
  124. /* What did the configure script discover about the outside world?  */
  125. #include "libguile/scmconfig.h"
  126.  
  127.  
  128. /* Write prototype declarations like this:
  129.      int foo SCM_P ((int a, int b));
  130.    At definitions, use K&R style declarations, but make sure there's a
  131.    declarative prototype (as above) in scope.  This will give you
  132.    argument type checking, when available, and be harmless otherwise.  */
  133. #ifdef __STDC__
  134. #  define SCM_P(x) x
  135. #else
  136. #  define SCM_P(x) ()
  137. #endif
  138.  
  139.  
  140.  
  141. /* Define
  142.  *
  143.  * SCM_CHAR_CODE_LIMIT        == UCHAR_MAX + 1
  144.  * SCM_MOST_POSITIVE_FIXNUM     (LONG_MAX>>2)
  145.  * SCM_MOST_NEGATIVE_FIXNUM     == SCM_SRS((long)LONG_MIN, 2)
  146.  */
  147.  
  148. #ifdef HAVE_LIMITS_H
  149. # include <limits.h>
  150. # ifdef UCHAR_MAX
  151. #  define SCM_CHAR_CODE_LIMIT (UCHAR_MAX+1L)
  152. # else
  153. #  define SCM_CHAR_CODE_LIMIT 256L
  154. # endif /* def UCHAR_MAX */
  155. # define SCM_MOST_POSITIVE_FIXNUM (LONG_MAX>>2)
  156. # ifdef _UNICOS            /* Stupid cray bug */
  157. #  define SCM_MOST_NEGATIVE_FIXNUM ((long)LONG_MIN/4)
  158. # else
  159. #  define SCM_MOST_NEGATIVE_FIXNUM SCM_SRS((long)LONG_MIN, 2)
  160. # endif                /* UNICOS */
  161. #else
  162. # define SCM_CHAR_CODE_LIMIT 256L
  163. # define SCM_MOST_POSITIVE_FIXNUM ((long)((unsigned long)~0L>>3))
  164. # if (0 != ~0)
  165. #  define SCM_MOST_NEGATIVE_FIXNUM (-SCM_MOST_POSITIVE_FIXNUM-1)
  166. # else
  167. #  define SCM_MOST_NEGATIVE_FIXNUM (-SCM_MOST_POSITIVE_FIXNUM)
  168. # endif /*  (0 != ~0) */
  169. #endif /* def HAVE_LIMITS_H */
  170.  
  171.  
  172. #ifdef STDC_HEADERS
  173. # include <stdlib.h>
  174. # ifdef AMIGA
  175. #  include <stddef.h>
  176. # endif /* def AMIGA */
  177. # define scm_sizet size_t
  178. #else
  179. # ifdef _SIZE_T
  180. #  define scm_sizet size_t
  181. # else
  182. #  define scm_sizet unsigned int
  183. # endif /* def _SIZE_T */
  184. #endif /* def STDC_HEADERS */
  185.  
  186.  
  187.  
  188. #include "libguile/tags.h"
  189.  
  190.  
  191. #ifdef vms
  192. # ifndef CHEAP_CONTINUATIONS
  193.    typedef int jmp_buf[17];
  194.    extern int setjump(jmp_buf env);
  195.    extern int longjump(jmp_buf env, int ret);
  196. #  define setjmp setjump
  197. #  define longjmp longjump
  198. # else
  199. #  include <setjmp.h>
  200. # endif
  201. #else                /* ndef vms */
  202. # ifdef _CRAY1
  203.     typedef int jmp_buf[112];
  204.     extern int setjump(jmp_buf env);
  205.     extern int longjump(jmp_buf env, int ret);
  206. #  define setjmp setjump
  207. #  define longjmp longjump
  208. # else                /* ndef _CRAY1 */
  209. #  include <setjmp.h>
  210. # endif                /* ndef _CRAY1 */
  211. #endif                /* ndef vms */
  212.  
  213. /* James Clark came up with this neat one instruction fix for
  214.  * continuations on the SPARC.  It flushes the register windows so
  215.  * that all the state of the process is contained in the stack. 
  216.  */
  217.  
  218. #ifdef sparc
  219. # define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3")
  220. #else
  221. # define SCM_FLUSH_REGISTER_WINDOWS /* empty */
  222. #endif
  223.  
  224. /* If stack is not longword aligned then 
  225.  */
  226.  
  227. /* #define SHORT_ALIGN */
  228. #ifdef THINK_C
  229. # define SHORT_ALIGN
  230. #endif
  231. #ifdef MSDOS
  232. # define SHORT_ALIGN
  233. #endif
  234. #ifdef atarist
  235. # define SHORT_ALIGN
  236. #endif
  237.  
  238. #ifdef SHORT_ALIGN
  239. typedef short SCM_STACKITEM;
  240. #else
  241. typedef long SCM_STACKITEM;
  242. #endif
  243.  
  244.  
  245. #ifndef USE_THREADS
  246. #define SCM_THREAD_DEFER
  247. #define SCM_THREAD_ALLOW
  248. #define SCM_THREAD_REDEFER
  249. #define SCM_THREAD_REALLOW_1
  250. #define SCM_THREAD_REALLOW_2
  251. #define SCM_THREAD_SWITCHING_CODE
  252. #endif
  253.  
  254. extern unsigned int scm_async_clock;
  255.  
  256. #define SCM_ASYNC_TICK \
  257. { \
  258.   if (0 == --scm_async_clock) \
  259.     scm_async_click (); \
  260. } \
  261.  
  262. #ifdef SCM_CAREFUL_INTS
  263. #define SCM_CHECK_NOT_DISABLED \
  264.   if (scm_ints_disabled) \
  265.     fputs("ints already disabled\n", stderr); \
  266.  
  267. #define SCM_CHECK_NOT_ENABLED \
  268.   if (!scm_ints_disabled) \
  269.     fputs("ints already enabled\n", stderr); \
  270.  
  271. #else
  272. #define SCM_CHECK_NOT_DISABLED
  273. #define SCM_CHECK_NOT_ENABLED
  274. #endif
  275.  
  276.  
  277. /* Anthony Green writes:
  278.    When the compiler sees...
  279.        DEFER_INTS;
  280.        [critical code here]
  281.        ALLOW_INTS;
  282.    ...it doesn't actually promise to keep the critical code within the
  283.    boundries of the DEFER/ALLOW_INTS instructions. It may very well
  284.    schedule it outside of the magic defined in those macros.
  285.  
  286.    However, GCC's volatile asm feature forms a barrier over which code is
  287.    never moved. So if you add...
  288.        asm volatile ("");
  289.    ...to each of the DEFER_INTS and ALLOW_INTS macros, the critical code
  290.    will always remain in place.  */
  291. #ifdef __GNUC__
  292. #define SCM_FENCE asm volatile ("")
  293. #else
  294. #define SCM_FENCE
  295. #endif
  296.  
  297. #define SCM_DEFER_INTS \
  298. { \
  299.   SCM_FENCE; \
  300.   SCM_CHECK_NOT_DISABLED; \
  301.   SCM_THREAD_DEFER; \
  302.   SCM_FENCE; \
  303.   scm_ints_disabled = 1; \
  304.   SCM_FENCE; \
  305. } \
  306.  
  307.  
  308. #define SCM_ALLOW_INTS_ONLY \
  309. { \
  310.   SCM_THREAD_ALLOW; \
  311.   scm_ints_disabled = 0; \
  312. } \
  313.  
  314.  
  315. #define SCM_ALLOW_INTS \
  316. { \
  317.   SCM_FENCE; \
  318.   SCM_CHECK_NOT_ENABLED; \
  319.   SCM_THREAD_SWITCHING_CODE; \
  320.   SCM_FENCE; \
  321.   scm_ints_disabled = 0; \
  322.   SCM_FENCE; \
  323.   SCM_THREAD_ALLOW; \
  324.   SCM_ASYNC_TICK; \
  325.   SCM_FENCE; \
  326. } \
  327.  
  328.  
  329. #define SCM_REDEFER_INTS  \
  330. { \
  331.   SCM_FENCE; \
  332.   SCM_THREAD_REDEFER; \
  333.   ++scm_ints_disabled; \
  334.   SCM_FENCE; \
  335. } \
  336.  
  337.  
  338. #define SCM_REALLOW_INTS \
  339. { \
  340.   SCM_FENCE; \
  341.   SCM_THREAD_REALLOW_1; \
  342.   SCM_THREAD_SWITCHING_CODE; \
  343.   SCM_FENCE; \
  344.   --scm_ints_disabled; \
  345.   if (!scm_ints_disabled) \
  346.     { \
  347.       SCM_THREAD_REALLOW_2; \
  348.       SCM_ASYNC_TICK; \
  349.     } \
  350.   SCM_FENCE; \
  351. } \
  352.  
  353.  
  354. #define SCM_TICK \
  355. { \
  356.   SCM_DEFER_INTS; \
  357.   SCM_ALLOW_INTS; \
  358. } \
  359.  
  360.  
  361.  
  362. /* Classification of critical sections
  363.  *
  364.  * When Guile moves to POSIX threads, it won't be possible to prevent
  365.  * context switching.  In fact, the whole idea of context switching is
  366.  * bogus if threads are run by different processors.  Therefore, we
  367.  * must ultimately eliminate all critical sections or enforce them by
  368.  * use of mutecis.
  369.  *
  370.  * All instances of SCM_DEFER_INTS and SCM_ALLOW_INTS should therefore
  371.  * be classified and replaced by one of the delimiters below.  If you
  372.  * understand what this is all about, I'd like to encourage you to
  373.  * help with this task.  The set of classes below must of course be
  374.  * incrementally augmented.
  375.  *
  376.  * MDJ 980419 <djurfeldt@nada.kth.se>
  377.  */
  378.  
  379. /* A sections
  380.  *
  381.  * Allocation of a cell with type tag in the CAR.
  382.  *
  383.  * With POSIX threads, each thread will have a private pool of free
  384.  * cells.  Therefore, this type of section can be removed.  But!  It
  385.  * is important that the CDR is initialized first (with the CAR still
  386.  * indicating a free cell) so that we can guarantee a consistent heap
  387.  * at all times.
  388.  */
  389.  
  390. #ifdef SCM_POSIX_THREADS
  391. #define SCM_ENTER_A_SECTION
  392. #define SCM_EXIT_A_SECTION
  393. #else
  394. #define SCM_ENTER_A_SECTION SCM_DEFER_INTS
  395. #define SCM_EXIT_A_SECTION SCM_ALLOW_INTS
  396. #endif
  397.  
  398.  
  399.  
  400. /** SCM_ASSERT
  401.  ** 
  402.  **/
  403.  
  404.  
  405. #ifdef SCM_RECKLESS
  406. #define SCM_ASSERT(_cond, _arg, _pos, _subr)
  407. #define SCM_ASRTGO(_cond, _label)
  408. #else
  409. #define SCM_ASSERT(_cond, _arg, _pos, _subr) \
  410.     if (!(_cond)) \
  411.           scm_wta(_arg, (char *)(_pos), _subr)
  412. #define SCM_ASRTGO(_cond, _label) \
  413.         if (!(_cond)) \
  414.           goto _label
  415. #endif
  416.  
  417. #define SCM_ARGn         0
  418. #define SCM_ARG1         1
  419. #define SCM_ARG2         2
  420. #define SCM_ARG3         3
  421. #define SCM_ARG4         4
  422. #define SCM_ARG5         5
  423. #define SCM_ARG6         6
  424. #define SCM_ARG7         7 
  425.      /* #define SCM_ARGERR(X)         ((X) < SCM_WNA \
  426.                  ? (char *)(X) \
  427.                  : "wrong type argument")
  428.                  */
  429.  
  430. /* Following must match entry indexes in scm_errmsgs[].
  431.  * Also, SCM_WNA must follow the last SCM_ARGn in sequence.
  432.  */
  433. #define SCM_WNA         8
  434.      /* #define SCM_OVSCM_FLOW         9 */
  435. #define SCM_OUTOFRANGE         10
  436. #define SCM_NALLOC         11
  437.      /* #define SCM_STACK_OVFLOW    12 */
  438.      /* #define SCM_EXIT         13 */
  439.  
  440.  
  441. /* (...still matching scm_errmsgs)  These
  442.  * are signals.  Signals may become errors
  443.  * but are distinguished because they first
  444.  * try to invoke a handler that can resume
  445.  * the interrupted routine.
  446.  */
  447. #define SCM_HUP_SIGNAL         14
  448. #define SCM_INT_SIGNAL         15
  449. #define SCM_FPE_SIGNAL         16
  450. #define SCM_BUS_SIGNAL         17
  451. #define SCM_SEGV_SIGNAL     18
  452. #define SCM_ALRM_SIGNAL     19
  453. #define SCM_GC_SIGNAL        20
  454. #define SCM_TICK_SIGNAL        21
  455.  
  456. #define SCM_SIG_ORD(X)        ((X) - SCM_HUP_SIGNAL)
  457. #define SCM_ORD_SIG(X)        ((X) + SCM_HUP_SIGNAL)
  458. #define SCM_NUM_SIGS        (SCM_SIG_ORD (SCM_TICK_SIGNAL) + 1)
  459.  
  460. #if 0
  461. struct errdesc
  462. {
  463.   char *msg;
  464.   char *s_response;
  465.   short parent_err;
  466. };
  467.  
  468.  
  469. extern struct errdesc scm_errmsgs[];
  470. #endif
  471.  
  472.  
  473.  
  474. /* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors
  475.  * were encountered.  SCM_EXIT_FAILURE is the default code to return from
  476.  * SCM if errors were encountered.  The return code can be explicitly
  477.  * specified in a SCM program with (scm_quit <n>).
  478.  */
  479.  
  480. #ifndef SCM_EXIT_SUCCESS
  481. #ifdef vms
  482. #define SCM_EXIT_SUCCESS 1
  483. #else
  484. #define SCM_EXIT_SUCCESS 0
  485. #endif /* def vms */
  486. #endif /* ndef SCM_EXIT_SUCCESS */
  487. #ifndef SCM_EXIT_FAILURE
  488. #ifdef vms
  489. #define SCM_EXIT_FAILURE 2
  490. #else
  491. #define SCM_EXIT_FAILURE 1
  492. #endif /* def vms */
  493. #endif /* ndef SCM_EXIT_FAILURE */
  494.  
  495.  
  496.  
  497.  
  498.  
  499. #endif  /* __SCMH */
  500.